home *** CD-ROM | disk | FTP | other *** search
/ Windows Game Programming for Dummies (2nd Edition) / WinGamProgFD.iso / mac / DirectX SDK / DXSDK / samples / Multimedia / Direct3D / DXTex / dxtexdoc.cpp < prev    next >
C/C++ Source or Header  |  2001-10-08  |  46KB  |  1,512 lines
  1. // dxtexDoc.cpp : implementation of the CDxtexDoc class
  2. //
  3.  
  4. #include "stdafx.h"
  5. #include "dxtex.h"
  6. #include "dxtexDoc.h"
  7. #include "dialogs.h"
  8. #include "dds.h"
  9.  
  10. #ifdef _DEBUG
  11. #define new DEBUG_NEW
  12. #undef THIS_FILE
  13. static char THIS_FILE[] = __FILE__;
  14. #endif
  15.  
  16. /////////////////////////////////////////////////////////////////////////////
  17. // CDxtexDoc
  18.  
  19. IMPLEMENT_DYNCREATE(CDxtexDoc, CDocument)
  20.  
  21. BEGIN_MESSAGE_MAP(CDxtexDoc, CDocument)
  22.     //{{AFX_MSG_MAP(CDxtexDoc)
  23.     ON_COMMAND(ID_FILE_OPENALPHA, OnFileOpenAlpha)
  24.     ON_COMMAND(ID_FORMAT_GENERATEMIPMAPS, OnGenerateMipMaps)
  25.     ON_COMMAND(ID_FORMAT_CHANGESURFACEFMT, OnFormatChangeSurfaceFmt)
  26.     ON_COMMAND(ID_FORMAT_CHANGECUBEMAPFACES, OnFormatChangeCubeMapFaces)
  27.     ON_COMMAND(ID_FORMAT_MAKEINTOVOLUMEMAP, OnFormatMakeIntoVolumeMap)
  28.     ON_UPDATE_COMMAND_UI(ID_FILE_OPENALPHA, OnUpdateFileOpenAlpha)
  29.     ON_UPDATE_COMMAND_UI(ID_FORMAT_GENERATEMIPMAPS, OnUpdateFormatGenerateMipmaps)
  30.     ON_UPDATE_COMMAND_UI(ID_FORMAT_CHANGECUBEMAPFACES, OnUpdateFormatChangeCubeMapFaces)
  31.     ON_UPDATE_COMMAND_UI(ID_FORMAT_MAKEINTOVOLUMEMAP, OnUpdateFormatMakeIntoVolumeMap)
  32.     //}}AFX_MSG_MAP
  33. END_MESSAGE_MAP()
  34.  
  35. /////////////////////////////////////////////////////////////////////////////
  36. // CDxtexDoc diagnostics
  37.  
  38. #ifdef _DEBUG
  39. void CDxtexDoc::AssertValid() const
  40. {
  41.     CDocument::AssertValid();
  42. }
  43.  
  44. void CDxtexDoc::Dump(CDumpContext& dc) const
  45. {
  46.     CDocument::Dump(dc);
  47. }
  48. #endif //_DEBUG
  49.  
  50. /////////////////////////////////////////////////////////////////////////////
  51. // CDxtexDoc construction/destruction
  52.  
  53. CDxtexDoc::CDxtexDoc()
  54. {
  55.     m_ptexOrig = NULL;
  56.     m_ptexNew = NULL;
  57.     m_dwWidth = 0;
  58.     m_dwHeight = 0;
  59.     m_dwDepth = 0;
  60.     m_numMips = 0;
  61.     m_dwCubeMapFlags = 0;
  62.     m_bTitleModsChanged = FALSE;
  63. }
  64.  
  65.  
  66. CDxtexDoc::~CDxtexDoc()
  67. {
  68.     ReleasePpo(&m_ptexOrig);
  69.     ReleasePpo(&m_ptexNew);
  70. }
  71.  
  72.  
  73. BOOL CDxtexDoc::OnNewDocument()
  74. {
  75.     HRESULT hr;
  76.     LPDIRECT3DDEVICE8 pd3ddev = PDxtexApp()->Pd3ddev();
  77.  
  78.     if (!CDocument::OnNewDocument())
  79.         return FALSE;
  80.  
  81.     CNewTextureDlg dlg;
  82.  
  83.     if (IDCANCEL == dlg.DoModal())
  84.         return FALSE;
  85.  
  86.     m_dwWidth = dlg.m_dwWidth;
  87.     m_dwHeight = dlg.m_dwHeight;
  88.     m_numMips = dlg.m_numMips;
  89.  
  90.     if (dlg.m_iTexType == 0)
  91.     {
  92.         LPDIRECT3DTEXTURE8 pmiptex;
  93.         hr = pd3ddev->CreateTexture(m_dwWidth, m_dwHeight, m_numMips, 
  94.             0, dlg.m_fmt, D3DPOOL_MANAGED, &pmiptex);
  95.         if (FAILED(hr))
  96.         {
  97.             AfxMessageBox(ID_ERROR_CANTCREATETEXTURE);
  98.             return FALSE;
  99.         }
  100.         m_ptexOrig = pmiptex;
  101.  
  102.     }
  103.     else if (dlg.m_iTexType == 1)
  104.     {
  105.         // Cube Map
  106.         LPDIRECT3DCUBETEXTURE8 pcubetex;
  107.         m_dwCubeMapFlags = DDS_CUBEMAP_ALLFACES;
  108.         hr = pd3ddev->CreateCubeTexture(m_dwWidth, m_numMips, 
  109.             0, dlg.m_fmt, D3DPOOL_MANAGED, &pcubetex);
  110.         if (FAILED(hr))
  111.         {
  112.             AfxMessageBox(ID_ERROR_CANTCREATETEXTURE);
  113.             return FALSE;
  114.         }
  115.         m_ptexOrig = pcubetex;
  116.     }
  117.     else
  118.     {
  119.         LPDIRECT3DVOLUMETEXTURE8 pvoltex;
  120.         m_dwDepth = dlg.m_dwDepth;
  121.         hr = pd3ddev->CreateVolumeTexture(m_dwWidth, m_dwHeight, m_dwDepth, m_numMips, 
  122.             0, dlg.m_fmt, D3DPOOL_SYSTEMMEM, &pvoltex);
  123.         if (FAILED(hr))
  124.         {
  125.             AfxMessageBox(ID_ERROR_CANTCREATETEXTURE);
  126.             return FALSE;
  127.         }
  128.         m_ptexOrig = pvoltex;
  129.     }
  130.  
  131.     return TRUE;
  132. }
  133.  
  134.  
  135. BOOL CDxtexDoc::OnOpenDocument(LPCTSTR lpszPathName)
  136. {
  137.     LPDIRECT3DDEVICE8 pd3ddev = PDxtexApp()->Pd3ddev();
  138.     D3DXIMAGE_INFO imageinfo;
  139.     D3DXIMAGE_INFO imageinfo2;
  140.  
  141.     if( FAILED( D3DXGetImageInfoFromFile( lpszPathName, &imageinfo ) ) )
  142.     {
  143.         AfxMessageBox(ID_ERROR_COULDNTLOADFILE);
  144.         return FALSE;
  145.     }
  146.  
  147.     switch( imageinfo.ResourceType )
  148.     {
  149.     case D3DRTYPE_TEXTURE:
  150.         if( FAILED( D3DXCreateTextureFromFileEx( pd3ddev, lpszPathName, 
  151.             imageinfo.Width, imageinfo.Height, imageinfo.MipLevels, 0,
  152.             imageinfo.Format, D3DPOOL_MANAGED, D3DX_FILTER_NONE, D3DX_FILTER_NONE, 0, 
  153.             &imageinfo2, NULL, (LPDIRECT3DTEXTURE8*)&m_ptexOrig ) ) )
  154.         {
  155.             AfxMessageBox(ID_ERROR_COULDNTLOADFILE);
  156.             return FALSE;
  157.         }
  158.         m_dwWidth = imageinfo2.Width;
  159.         m_dwHeight = imageinfo2.Height;
  160.         m_dwDepth = 0;
  161.         m_numMips = imageinfo2.MipLevels;
  162.  
  163.         if( imageinfo.ImageFileFormat == D3DXIFF_BMP )
  164.         {
  165.             // Look for "foo_a.bmp" for alpha channel
  166.             CString strPath = lpszPathName;
  167.             int i = strPath.ReverseFind('.');
  168.             HRESULT hr;
  169.             strPath = strPath.Left(i) + "_a.bmp";
  170.             CFileStatus status;
  171.             if (CFile::GetStatus(strPath, status))
  172.             {
  173.                 // Make sure there's an alpha channel to load alpha image into
  174.                 if (FAILED(EnsureAlpha(&m_ptexOrig)))
  175.                     return FALSE;
  176.  
  177.                 LPDIRECT3DSURFACE8 psurf;
  178.  
  179.                 hr = ((LPDIRECT3DTEXTURE8)m_ptexOrig)->GetSurfaceLevel(0, &psurf);
  180.                 if (FAILED(hr))
  181.                     return FALSE;
  182.  
  183.                 hr = LoadAlphaIntoSurface(strPath, psurf);
  184.                 ReleasePpo(&psurf);
  185.                 if (FAILED(hr))
  186.                     return FALSE;
  187.  
  188.             }
  189.         }
  190.         break;
  191.  
  192.     case D3DRTYPE_VOLUMETEXTURE:
  193.         if( FAILED( D3DXCreateVolumeTextureFromFileEx( pd3ddev, lpszPathName, 
  194.             imageinfo.Width, imageinfo.Height, imageinfo.Depth, imageinfo.MipLevels,
  195.             0, imageinfo.Format, D3DPOOL_MANAGED, D3DX_FILTER_NONE, D3DX_FILTER_NONE,
  196.             0, &imageinfo2, NULL, (LPDIRECT3DVOLUMETEXTURE8*)&m_ptexOrig ) ) )
  197.         {
  198.             AfxMessageBox(ID_ERROR_COULDNTLOADFILE);
  199.             return FALSE;
  200.         }
  201.         m_dwWidth = imageinfo2.Width;
  202.         m_dwHeight = imageinfo2.Height;
  203.         m_dwDepth = imageinfo2.Depth;
  204.         m_numMips = imageinfo2.MipLevels;
  205.         break;
  206.  
  207.     case D3DRTYPE_CUBETEXTURE:
  208.         if( FAILED( D3DXCreateCubeTextureFromFileEx( pd3ddev, lpszPathName, 
  209.             imageinfo.Width, imageinfo.MipLevels, 0, imageinfo.Format, 
  210.             D3DPOOL_MANAGED, D3DX_FILTER_NONE, D3DX_FILTER_NONE, 
  211.             0, &imageinfo2, NULL, (LPDIRECT3DCUBETEXTURE8*)&m_ptexOrig ) ) )
  212.         {
  213.             AfxMessageBox(ID_ERROR_COULDNTLOADFILE);
  214.             return FALSE;
  215.         }
  216.         m_dwWidth = imageinfo2.Width;
  217.         m_dwHeight = imageinfo2.Height;
  218.         m_dwDepth = 0;
  219.         m_numMips = imageinfo2.MipLevels;
  220.         m_dwCubeMapFlags = DDS_CUBEMAP_ALLFACES;
  221.         break;
  222.  
  223.     default:
  224.         AfxMessageBox(ID_ERROR_COULDNTLOADFILE);
  225.         return FALSE;
  226.     }
  227.  
  228.     return TRUE;
  229. }
  230.  
  231.  
  232. BOOL CDxtexDoc::OnSaveDocument(LPCTSTR lpszPathName)
  233. {
  234.     LPDIRECT3DBASETEXTURE8 ptex;
  235.     ptex = (m_ptexNew == NULL ? m_ptexOrig : m_ptexNew);
  236.     
  237.     if( FAILED( D3DXSaveTextureToFile( lpszPathName, D3DXIFF_DDS, ptex, NULL ) ) )
  238.     {
  239.         AfxMessageBox(ID_ERROR_COULDNTSAVEFILE);
  240.         return FALSE;
  241.     }
  242.     
  243.     SetModifiedFlag(FALSE);
  244.  
  245.     return TRUE;
  246. }
  247.  
  248.  
  249.  
  250.  
  251. D3DFORMAT CDxtexDoc::GetFormat(LPDIRECT3DBASETEXTURE8 ptex)
  252. {
  253.     LPDIRECT3DTEXTURE8 pmiptex = NULL;
  254.     LPDIRECT3DCUBETEXTURE8 pcubetex = NULL;
  255.     LPDIRECT3DVOLUMETEXTURE8 pvoltex = NULL;
  256.     D3DFORMAT fmt;
  257.  
  258.     if (IsVolumeMap())
  259.         pvoltex = (LPDIRECT3DVOLUMETEXTURE8)ptex;
  260.     else if (IsCubeMap())
  261.         pcubetex = (LPDIRECT3DCUBETEXTURE8)ptex;
  262.     else
  263.         pmiptex = (LPDIRECT3DTEXTURE8)ptex;
  264.  
  265.     if (pvoltex != NULL)
  266.     {
  267.         D3DVOLUME_DESC vd;
  268.         pvoltex->GetLevelDesc(0, &vd);
  269.         fmt = vd.Format;
  270.     }
  271.     else if (pcubetex != NULL)
  272.     {
  273.         D3DSURFACE_DESC sd;
  274.         pcubetex->GetLevelDesc(0, &sd);
  275.         fmt = sd.Format;
  276.     }
  277.     else
  278.     {
  279.         D3DSURFACE_DESC sd;
  280.         pmiptex->GetLevelDesc(0, &sd);
  281.         fmt = sd.Format;
  282.     }
  283.     return fmt;
  284. }
  285.  
  286.  
  287.  
  288. // If *pptex's current format has less than 4 bits of alpha, change
  289. // it to a similar format that has at least 4 bits of alpha.
  290. HRESULT CDxtexDoc::EnsureAlpha(LPDIRECT3DBASETEXTURE8* pptex)
  291. {
  292.     HRESULT hr;
  293.     D3DFORMAT fmtCur = GetFormat(*pptex);
  294.     D3DFORMAT fmtNew = D3DFMT_UNKNOWN;
  295.     LPDIRECT3DBASETEXTURE8 ptex;
  296.  
  297.     switch (fmtCur)
  298.     {
  299.     case D3DFMT_R8G8B8:
  300.         fmtNew = D3DFMT_A8R8G8B8;
  301.         break;
  302.     default:
  303.         break;
  304.     }
  305.  
  306.     if( fmtNew != D3DFMT_UNKNOWN )
  307.     {
  308.         if (FAILED(hr = ChangeFormat(m_ptexOrig, fmtNew, &ptex)))
  309.             return hr;
  310.         ReleasePpo(&m_ptexOrig);
  311.         m_ptexOrig = ptex;
  312.     }
  313.  
  314.     return S_OK;
  315. }
  316.  
  317.  
  318.  
  319.  
  320. /////////////////////////////////////////////////////////////////////////////
  321. // CDxtexDoc commands
  322.  
  323. HRESULT CDxtexDoc::LoadAlphaBmp(CString& strPath)
  324. {
  325.     HRESULT hr;
  326.     LPDIRECT3DTEXTURE8 pmiptex;
  327.     LPDIRECT3DSURFACE8 psurf;
  328.  
  329.     if (IsCubeMap())
  330.         return E_FAIL;
  331.  
  332.     pmiptex = (LPDIRECT3DTEXTURE8)m_ptexOrig;
  333.     hr = pmiptex->GetSurfaceLevel(0, &psurf);
  334.     if (FAILED(hr))
  335.         return hr;
  336.  
  337.     hr = LoadAlphaIntoSurface(strPath, psurf);
  338.     ReleasePpo(&psurf);
  339.     if (FAILED(hr))
  340.         return hr;
  341.     
  342.     UpdateAllViews(NULL, 1); // tell CView to pick up new surface pointers
  343.     return S_OK;
  344. }
  345.  
  346.  
  347.  
  348.  
  349. HRESULT CDxtexDoc::ChangeFormat(LPDIRECT3DBASETEXTURE8 ptexCur, D3DFORMAT fmtTo, 
  350.                                 LPDIRECT3DBASETEXTURE8* pptexNew)
  351. {
  352.     HRESULT hr;
  353.     LPDIRECT3DDEVICE8 pd3ddev = PDxtexApp()->Pd3ddev();
  354.     LPDIRECT3DTEXTURE8 pmiptex;
  355.     LPDIRECT3DCUBETEXTURE8 pcubetex;
  356.     LPDIRECT3DVOLUMETEXTURE8 pvoltex;
  357.     D3DFORMAT fmtFrom;
  358.     LPDIRECT3DTEXTURE8 pmiptexNew;
  359.     LPDIRECT3DCUBETEXTURE8 pcubetexNew;
  360.     LPDIRECT3DVOLUMETEXTURE8 pvoltexNew;
  361.  
  362.     if (IsVolumeMap())
  363.     {
  364.         pvoltex = (LPDIRECT3DVOLUMETEXTURE8)ptexCur;
  365.         D3DVOLUME_DESC vd;
  366.         pvoltex->GetLevelDesc(0, &vd);
  367.         fmtFrom = vd.Format;
  368.     }
  369.     else if (IsCubeMap())
  370.     {
  371.         pcubetex = (LPDIRECT3DCUBETEXTURE8)ptexCur;
  372.         D3DSURFACE_DESC sd;
  373.         pcubetex->GetLevelDesc(0, &sd);
  374.         fmtFrom = sd.Format;
  375.     }
  376.     else
  377.     {
  378.         pmiptex = (LPDIRECT3DTEXTURE8)ptexCur;
  379.         D3DSURFACE_DESC sd;
  380.         pmiptex->GetLevelDesc(0, &sd);
  381.         fmtFrom = sd.Format;
  382.     }
  383.  
  384.     if (fmtFrom == D3DFMT_DXT2 || fmtFrom == D3DFMT_DXT4)
  385.     {
  386.         if (fmtTo == D3DFMT_DXT1)
  387.         {
  388.             AfxMessageBox(ID_ERROR_PREMULTTODXT1);
  389.         }
  390.         else if (fmtTo != D3DFMT_DXT2 && fmtTo != D3DFMT_DXT4)
  391.         {
  392.             AfxMessageBox(ID_ERROR_PREMULTALPHA);
  393.             return S_OK;
  394.         }
  395.     }
  396.  
  397.     if (IsVolumeMap())
  398.     {
  399.         hr = pd3ddev->CreateVolumeTexture(m_dwWidth, m_dwHeight, m_dwDepth, m_numMips,
  400.             0, fmtTo, D3DPOOL_SYSTEMMEM, &pvoltexNew);
  401.         if (FAILED(hr))
  402.             return hr;
  403.         *pptexNew = pvoltexNew;
  404.         if (FAILED(BltAllLevels(D3DCUBEMAP_FACE_FORCE_DWORD, ptexCur, *pptexNew)))
  405.             return hr;
  406.     }
  407.     else if (IsCubeMap())
  408.     {
  409.         hr = pd3ddev->CreateCubeTexture(m_dwWidth, m_numMips, 
  410.              0, fmtTo, D3DPOOL_MANAGED, &pcubetexNew);
  411.         if (FAILED(hr))
  412.             return hr;
  413.         *pptexNew = pcubetexNew;
  414.         if (FAILED(hr = BltAllLevels(D3DCUBEMAP_FACE_NEGATIVE_X, ptexCur, *pptexNew)))
  415.             return hr;
  416.         if (FAILED(hr = BltAllLevels(D3DCUBEMAP_FACE_POSITIVE_X, ptexCur, *pptexNew)))
  417.             return hr;
  418.         if (FAILED(hr = BltAllLevels(D3DCUBEMAP_FACE_NEGATIVE_Y, ptexCur, *pptexNew)))
  419.             return hr;
  420.         if (FAILED(hr = BltAllLevels(D3DCUBEMAP_FACE_POSITIVE_Y, ptexCur, *pptexNew)))
  421.             return hr;
  422.         if (FAILED(hr = BltAllLevels(D3DCUBEMAP_FACE_NEGATIVE_Z, ptexCur, *pptexNew)))
  423.             return hr;
  424.         if (FAILED(hr = BltAllLevels(D3DCUBEMAP_FACE_POSITIVE_Z, ptexCur, *pptexNew)))
  425.             return hr;
  426.     }
  427.     else
  428.     {
  429.         hr = pd3ddev->CreateTexture(m_dwWidth, m_dwHeight, m_numMips, 
  430.              0, fmtTo, D3DPOOL_MANAGED, &pmiptexNew);
  431.         if (FAILED(hr))
  432.             return hr;
  433.         *pptexNew = pmiptexNew;
  434.         if (FAILED(BltAllLevels(D3DCUBEMAP_FACE_FORCE_DWORD, ptexCur, *pptexNew)))
  435.             return hr;
  436.     }
  437.     return S_OK;
  438. }
  439.  
  440.  
  441.  
  442.  
  443. HRESULT CDxtexDoc::Compress(D3DFORMAT fmtTo, BOOL bSwitchView)
  444. {
  445.     HRESULT hr;
  446.     LPDIRECT3DBASETEXTURE8 ptexNew;
  447.  
  448.     if (FAILED(hr = ChangeFormat(m_ptexOrig, fmtTo, &ptexNew)))
  449.         return hr;
  450.  
  451.     ReleasePpo(&m_ptexNew);
  452.     m_ptexNew = ptexNew;
  453.  
  454.     SetModifiedFlag();
  455.     m_bTitleModsChanged = TRUE; // force title bar update
  456.     if (bSwitchView)
  457.         AfxGetMainWnd()->PostMessage(WM_COMMAND, ID_VIEW_COMPRESSED, 0);
  458.  
  459.     return S_OK;
  460. }
  461.  
  462.  
  463.  
  464.  
  465. void CDxtexDoc::OnGenerateMipMaps() 
  466. {
  467.     GenerateMipMaps();
  468. }
  469.  
  470.  
  471.  
  472.  
  473. void CDxtexDoc::GenerateMipMaps() 
  474. {
  475.     LONG lwTempH;
  476.     LONG lwTempW;
  477.     LONG lwPowsW;
  478.     LONG lwPowsH;
  479.     LPDIRECT3DTEXTURE8 pddsNew = NULL;
  480.     D3DFORMAT fmt;
  481.     HRESULT hr;
  482.     LPDIRECT3DDEVICE8 pd3ddev = PDxtexApp()->Pd3ddev();
  483.     LPDIRECT3DTEXTURE8 pmiptex = NULL;
  484.     LPDIRECT3DCUBETEXTURE8 pcubetex = NULL;
  485.     LPDIRECT3DVOLUMETEXTURE8 pvoltex = NULL;
  486.     LPDIRECT3DTEXTURE8 pmiptexNew = NULL;
  487.     LPDIRECT3DCUBETEXTURE8 pcubetexNew = NULL;
  488.     LPDIRECT3DVOLUMETEXTURE8 pvoltexNew = NULL;
  489.     LPDIRECT3DSURFACE8 psurfSrc;
  490.     LPDIRECT3DSURFACE8 psurfDest;
  491.     LPDIRECT3DVOLUME8 pvolSrc;
  492.     LPDIRECT3DVOLUME8 pvolDest;
  493.  
  494.     if (IsVolumeMap())
  495.         pvoltex = (LPDIRECT3DVOLUMETEXTURE8)m_ptexOrig;
  496.     else if (IsCubeMap())
  497.         pcubetex = (LPDIRECT3DCUBETEXTURE8)m_ptexOrig;
  498.     else
  499.         pmiptex = (LPDIRECT3DTEXTURE8)m_ptexOrig;
  500.  
  501.     if (pvoltex != NULL)
  502.     {
  503.         D3DVOLUME_DESC vd;
  504.         pvoltex->GetLevelDesc(0, &vd);
  505.         fmt = vd.Format;
  506.     }
  507.     else if (pcubetex != NULL)
  508.     {
  509.         D3DSURFACE_DESC sd;
  510.         pcubetex->GetLevelDesc(0, &sd);
  511.         fmt = sd.Format;
  512.     }
  513.     else
  514.     {
  515.         D3DSURFACE_DESC sd;
  516.         pmiptex->GetLevelDesc(0, &sd);
  517.         fmt = sd.Format;
  518.     }
  519.  
  520.     lwTempW = m_dwWidth;
  521.     lwTempH = m_dwHeight;
  522.     lwPowsW = 0;
  523.     lwPowsH = 0;
  524.     while (lwTempW > 0)
  525.     {
  526.         lwPowsW++;
  527.         lwTempW = lwTempW / 2;
  528.     }
  529.     while (lwTempH > 0)
  530.     {
  531.         lwPowsH++;
  532.         lwTempH = lwTempH / 2;
  533.     }
  534.     m_numMips = lwPowsW > lwPowsH ? lwPowsW : lwPowsH;
  535.  
  536.     // Create destination mipmap surface - same format as source
  537.     if (pvoltex != NULL)
  538.     {
  539.         if (FAILED(hr = pd3ddev->CreateVolumeTexture(m_dwWidth, m_dwHeight, m_dwDepth, 
  540.             m_numMips, 0, fmt, D3DPOOL_SYSTEMMEM, &pvoltexNew)))
  541.         {
  542.             goto LFail;
  543.         }
  544.         hr = pvoltex->GetVolumeLevel(0, &pvolSrc);
  545.         hr = pvoltexNew->GetVolumeLevel(0, &pvolDest);
  546.         hr = D3DXLoadVolumeFromVolume(pvolDest, NULL, NULL, pvolSrc, NULL, NULL, 
  547.             D3DX_FILTER_TRIANGLE, 0);
  548.         ReleasePpo(&pvolSrc);
  549.         ReleasePpo(&pvolDest);
  550.         hr = D3DXFilterVolumeTexture(pvoltexNew, NULL, 0, D3DX_FILTER_TRIANGLE);
  551.     }
  552.     else if (pmiptex != NULL)
  553.     {
  554.         if (FAILED(hr = pd3ddev->CreateTexture(m_dwWidth, m_dwHeight, m_numMips, 
  555.              0, fmt, D3DPOOL_MANAGED, &pmiptexNew)))
  556.         {
  557.             goto LFail;
  558.         }
  559.         hr = pmiptex->GetSurfaceLevel(0, &psurfSrc);
  560.         hr = pmiptexNew->GetSurfaceLevel(0, &psurfDest);
  561.         hr = D3DXLoadSurfaceFromSurface(psurfDest, NULL, NULL, psurfSrc, NULL, NULL, 
  562.             D3DX_FILTER_TRIANGLE, 0);
  563.         ReleasePpo(&psurfSrc);
  564.         ReleasePpo(&psurfDest);
  565.         hr = D3DXFilterTexture(pmiptexNew, NULL, 0, D3DX_FILTER_TRIANGLE);
  566.     }
  567.     else
  568.     {
  569.         if (FAILED(hr = pd3ddev->CreateCubeTexture(m_dwWidth, m_numMips, 
  570.              0, fmt, D3DPOOL_MANAGED, &pcubetexNew)))
  571.         {
  572.             goto LFail;
  573.         }
  574.         hr = pcubetex->GetCubeMapSurface(D3DCUBEMAP_FACE_POSITIVE_X, 0, &psurfSrc);
  575.         hr = pcubetexNew->GetCubeMapSurface(D3DCUBEMAP_FACE_POSITIVE_X, 0, &psurfDest);
  576.         hr = D3DXLoadSurfaceFromSurface(psurfDest, NULL, NULL, psurfSrc, NULL, NULL, 
  577.             D3DX_FILTER_TRIANGLE, 0);
  578.         ReleasePpo(&psurfSrc);
  579.         ReleasePpo(&psurfDest);
  580.         hr = pcubetex->GetCubeMapSurface(D3DCUBEMAP_FACE_NEGATIVE_X, 0, &psurfSrc);
  581.         hr = pcubetexNew->GetCubeMapSurface(D3DCUBEMAP_FACE_NEGATIVE_X, 0, &psurfDest);
  582.         hr = D3DXLoadSurfaceFromSurface(psurfDest, NULL, NULL, psurfSrc, NULL, NULL, 
  583.             D3DX_FILTER_TRIANGLE, 0);
  584.         ReleasePpo(&psurfSrc);
  585.         ReleasePpo(&psurfDest);
  586.         hr = pcubetex->GetCubeMapSurface(D3DCUBEMAP_FACE_POSITIVE_Y, 0, &psurfSrc);
  587.         hr = pcubetexNew->GetCubeMapSurface(D3DCUBEMAP_FACE_POSITIVE_Y, 0, &psurfDest);
  588.         hr = D3DXLoadSurfaceFromSurface(psurfDest, NULL, NULL, psurfSrc, NULL, NULL, 
  589.             D3DX_FILTER_TRIANGLE, 0);
  590.         ReleasePpo(&psurfSrc);
  591.         ReleasePpo(&psurfDest);
  592.         hr = pcubetex->GetCubeMapSurface(D3DCUBEMAP_FACE_NEGATIVE_Y, 0, &psurfSrc);
  593.         hr = pcubetexNew->GetCubeMapSurface(D3DCUBEMAP_FACE_NEGATIVE_Y, 0, &psurfDest);
  594.         hr = D3DXLoadSurfaceFromSurface(psurfDest, NULL, NULL, psurfSrc, NULL, NULL, 
  595.             D3DX_FILTER_TRIANGLE, 0);
  596.         ReleasePpo(&psurfSrc);
  597.         ReleasePpo(&psurfDest);
  598.         hr = pcubetex->GetCubeMapSurface(D3DCUBEMAP_FACE_POSITIVE_Z, 0, &psurfSrc);
  599.         hr = pcubetexNew->GetCubeMapSurface(D3DCUBEMAP_FACE_POSITIVE_Z, 0, &psurfDest);
  600.         hr = D3DXLoadSurfaceFromSurface(psurfDest, NULL, NULL, psurfSrc, NULL, NULL, 
  601.             D3DX_FILTER_TRIANGLE, 0);
  602.         ReleasePpo(&psurfSrc);
  603.         ReleasePpo(&psurfDest);
  604.         hr = pcubetex->GetCubeMapSurface(D3DCUBEMAP_FACE_NEGATIVE_Z, 0, &psurfSrc);
  605.         hr = pcubetexNew->GetCubeMapSurface(D3DCUBEMAP_FACE_NEGATIVE_Z, 0, &psurfDest);
  606.         hr = D3DXLoadSurfaceFromSurface(psurfDest, NULL, NULL, psurfSrc, NULL, NULL, 
  607.             D3DX_FILTER_TRIANGLE, 0);
  608.         ReleasePpo(&psurfSrc);
  609.         ReleasePpo(&psurfDest);
  610.         hr = D3DXFilterCubeTexture(pcubetexNew, NULL, 0, D3DX_FILTER_TRIANGLE);
  611.     }
  612.  
  613.     ReleasePpo(&m_ptexOrig);
  614.     if (pvoltexNew != NULL)
  615.         m_ptexOrig = pvoltexNew;
  616.     else if (pcubetexNew != NULL)
  617.         m_ptexOrig = pcubetexNew;
  618.     else
  619.         m_ptexOrig = pmiptexNew;
  620.  
  621.     if (m_ptexNew != NULL)
  622.     {
  623.         // Rather than filtering down the (probably-compressed) m_ptexNew 
  624.         // top level, compress each mip level from the (probably-uncompressed)
  625.         // m_ptexOrig levels.
  626.         if (pvoltexNew != NULL)
  627.         {
  628.             D3DVOLUME_DESC vd;
  629.             ((LPDIRECT3DVOLUMETEXTURE8)m_ptexNew)->GetLevelDesc(0, &vd);
  630.             fmt = vd.Format;
  631.         }
  632.         else if (pcubetexNew != NULL)
  633.         {
  634.             D3DSURFACE_DESC sd;
  635.             ((LPDIRECT3DTEXTURE8)m_ptexNew)->GetLevelDesc(0, &sd);
  636.             fmt = sd.Format;
  637.         }
  638.         else
  639.         {
  640.             D3DSURFACE_DESC sd;
  641.             ((LPDIRECT3DCUBETEXTURE8)m_ptexNew)->GetLevelDesc(0, &sd);
  642.             fmt = sd.Format;
  643.         }
  644.         Compress(fmt, FALSE);
  645.     }
  646.  
  647.     m_bTitleModsChanged = TRUE; // Generate title bar update
  648.     UpdateAllViews(NULL, 1); // tell CView to pick up new surface pointers
  649.     SetModifiedFlag();
  650.     return;
  651.  
  652. LFail:
  653.     ReleasePpo(&pddsNew);
  654. }
  655.  
  656.  
  657. void CDxtexDoc::SetPathName(LPCTSTR lpszPathName, BOOL bAddToMRU) 
  658. {
  659.     CDocument::SetPathName(lpszPathName, bAddToMRU);
  660.  
  661.     TCHAR* pszLeaf = strrchr(lpszPathName, '\\') + 1;
  662.     TCHAR* pszExtension = strrchr(lpszPathName, '.');
  663.     if (lstrcmpi(pszExtension, ".dds") != 0)
  664.     {
  665.         lstrcpy(pszExtension, "");
  666.         SetModifiedFlag(TRUE);
  667.         SetTitle(pszLeaf);
  668.         m_strPathName.Empty();
  669.     }
  670. }
  671.  
  672. DWORD CDxtexDoc::NumMips(VOID)
  673. {
  674.     return m_numMips;
  675. }
  676.  
  677.  
  678. void CDxtexDoc::OnFileOpenAlpha() 
  679. {
  680.     HRESULT hr;
  681.     CString fileName;
  682.     LPDIRECT3DTEXTURE8 pmiptex;
  683.  
  684.     if (IsCubeMap() || IsVolumeMap())
  685.         return;
  686.  
  687.     // Premultiplied-alpha files don't support this feature:
  688.     D3DSURFACE_DESC sd;
  689.     ((LPDIRECT3DTEXTURE8)m_ptexOrig)->GetLevelDesc(0, &sd);
  690.     if (sd.Format == D3DFMT_DXT2 || sd.Format == D3DFMT_DXT4)
  691.     {
  692.         AfxMessageBox(ID_ERROR_PREMULTALPHA);
  693.         return;
  694.     }
  695.  
  696.     // Check if the original has alpha
  697.     if( sd.Format != D3DFMT_A8R8G8B8 && 
  698.         sd.Format != D3DFMT_A1R5G5B5 && 
  699.         sd.Format != D3DFMT_A4R4G4B4 && 
  700.         sd.Format != D3DFMT_A8R3G3B2 && 
  701.         sd.Format != D3DFMT_DXT1 && 
  702.         sd.Format != D3DFMT_DXT3 && 
  703.         sd.Format != D3DFMT_DXT5 )
  704.     {
  705.         // If it doesn't then see if the new does
  706.         if (m_ptexNew != NULL)
  707.         {
  708.             ((LPDIRECT3DTEXTURE8)m_ptexNew)->GetLevelDesc(0, &sd);
  709.             if(sd.Format != D3DFMT_A8R8G8B8 && 
  710.                sd.Format != D3DFMT_A1R5G5B5 && 
  711.                sd.Format != D3DFMT_A4R4G4B4 && 
  712.                sd.Format != D3DFMT_A8R3G3B2 && 
  713.                sd.Format != D3DFMT_DXT1 && 
  714.                sd.Format != D3DFMT_DXT3 && 
  715.                sd.Format != D3DFMT_DXT5 )
  716.             {
  717.                 AfxMessageBox(ID_ERROR_NEEDALPHA);
  718.                 return;
  719.             }
  720.             else
  721.             {
  722.                 ReleasePpo(&m_ptexOrig);
  723.                 m_ptexOrig = m_ptexNew;
  724.                 m_ptexNew  = NULL;
  725.                 AfxGetMainWnd()->PostMessage(WM_COMMAND, ID_VIEW_ORIGINAL, 0);
  726.             }
  727.         }
  728.         else
  729.         {
  730.                 AfxMessageBox(ID_ERROR_NEEDALPHA);
  731.                 return;
  732.         }
  733.     }
  734.  
  735.     pmiptex = (LPDIRECT3DTEXTURE8)m_ptexOrig;
  736.  
  737.     if (!PromptForBmp(&fileName))
  738.         return;
  739.  
  740.     LPDIRECT3DSURFACE8 psurf;
  741.     if (FAILED(hr = pmiptex->GetSurfaceLevel(0, &psurf)))
  742.         return;
  743.  
  744.     if (FAILED(hr = LoadAlphaIntoSurface(fileName, psurf)))
  745.         return;
  746.     if (m_numMips > 1)
  747.         OnGenerateMipMaps();
  748.     else if (m_ptexNew != NULL)
  749.     {
  750.         ((LPDIRECT3DTEXTURE8)m_ptexNew)->GetLevelDesc(0, &sd);
  751.         Compress(sd.Format, FALSE);
  752.     }
  753.     UpdateAllViews(NULL, 1);
  754. }
  755.  
  756.  
  757. HRESULT CDxtexDoc::LoadAlphaIntoSurface(CString& strPath, LPDIRECT3DSURFACE8 psurf)
  758. {
  759.     HRESULT hr;
  760.     D3DSURFACE_DESC sd;
  761.     LPDIRECT3DDEVICE8 pd3ddev = PDxtexApp()->Pd3ddev();
  762.     LPDIRECT3DTEXTURE8 ptexAlpha;
  763.     LPDIRECT3DSURFACE8 psurfAlpha;
  764.     LPDIRECT3DSURFACE8 psurfTarget;
  765.  
  766.     psurf->GetDesc(&sd);
  767.  
  768.     // Load the alpha BMP into psurfAlpha, a new A8R8G8B8 surface
  769.     hr = D3DXCreateTextureFromFileEx(pd3ddev, strPath, sd.Width, sd.Height, 1, 0, 
  770.         D3DFMT_A8R8G8B8, D3DPOOL_MANAGED, D3DX_FILTER_TRIANGLE, 
  771.         D3DX_FILTER_TRIANGLE, 0, NULL, NULL, &ptexAlpha);
  772.     hr = ptexAlpha->GetSurfaceLevel(0, &psurfAlpha);
  773.  
  774.     // Copy the target surface into an A8R8G8B8 surface
  775.     hr = pd3ddev->CreateImageSurface(sd.Width, sd.Height, D3DFMT_A8R8G8B8, &psurfTarget);
  776.     hr = D3DXLoadSurfaceFromSurface(psurfTarget, NULL, NULL, psurf, NULL, NULL, 
  777.         D3DX_FILTER_TRIANGLE, 0);
  778.  
  779.     // Fill in the alpha channels of psurfTarget based on the blue channel of psurfAlpha
  780.     D3DLOCKED_RECT lrSrc;
  781.     D3DLOCKED_RECT lrDest;
  782.  
  783.     hr = psurfAlpha->LockRect(&lrSrc, NULL, D3DLOCK_READONLY);
  784.     hr = psurfTarget->LockRect(&lrDest, NULL, 0);
  785.  
  786.     DWORD xp;
  787.     DWORD yp;
  788.     DWORD* pdwRowSrc = (DWORD*)lrSrc.pBits;
  789.     DWORD* pdwRowDest = (DWORD*)lrDest.pBits;
  790.     DWORD* pdwSrc;
  791.     DWORD* pdwDest;
  792.     DWORD dwAlpha;
  793.     LONG dataBytesPerRow = 4 * sd.Width;
  794.  
  795.     for (yp = 0; yp < sd.Height; yp++)
  796.     {
  797.         pdwSrc = pdwRowSrc;
  798.         pdwDest = pdwRowDest;
  799.         for (xp = 0; xp < sd.Width; xp++)
  800.         {
  801.             dwAlpha = *pdwSrc << 24;
  802.             *pdwDest &= 0x00ffffff;
  803.             *pdwDest |= dwAlpha;
  804.  
  805.             pdwSrc++;
  806.             pdwDest++;
  807.         }
  808.         pdwRowSrc += lrSrc.Pitch / 4;
  809.         pdwRowDest += lrDest.Pitch / 4;
  810.     }
  811.  
  812.     psurfAlpha->UnlockRect();
  813.     psurfTarget->UnlockRect();
  814.  
  815.     // Copy psurfTarget back into real surface
  816.     hr = D3DXLoadSurfaceFromSurface(psurf, NULL, NULL, psurfTarget, NULL, NULL, 
  817.         D3DX_FILTER_TRIANGLE, 0);
  818.     
  819.     // Release allocated interfaces
  820.     ReleasePpo(&psurfTarget);
  821.     ReleasePpo(&psurfAlpha);
  822.     ReleasePpo(&ptexAlpha);
  823.  
  824.     return S_OK;
  825. }
  826.  
  827.  
  828. BOOL CDxtexDoc::PromptForBmp(CString* pstrPath)
  829. {
  830.     CFileDialog dlgFile(TRUE);
  831.  
  832.     CString title;
  833.     VERIFY(title.LoadString(AFX_IDS_OPENFILE));
  834.  
  835.     CString strFilter;
  836.     CString strDefault;
  837.  
  838.     strFilter += "Image Files (*.dds, *.bmp, *.tga, *.jpg, *.png, *.dib)";
  839.     strFilter += (TCHAR)'\0';   // next string please
  840.     strFilter += _T("*.dds;*.bmp;*.tga;*.jpg;*.png;*.dib");
  841.     strFilter += (TCHAR)'\0';   // last string
  842.     dlgFile.m_ofn.nMaxCustFilter++;
  843.  
  844.     // append the "*.*" all files filter
  845.     CString allFilter;
  846.     VERIFY(allFilter.LoadString(AFX_IDS_ALLFILTER));
  847.     strFilter += allFilter;
  848.     strFilter += (TCHAR)'\0';   // next string please
  849.     strFilter += _T("*.*");
  850.     strFilter += (TCHAR)'\0';   // last string
  851.     dlgFile.m_ofn.nMaxCustFilter++;
  852.  
  853.     dlgFile.m_ofn.lpstrFilter = strFilter;
  854.     dlgFile.m_ofn.lpstrTitle = title;
  855.     dlgFile.m_ofn.lpstrFile = pstrPath->GetBuffer(_MAX_PATH);
  856.  
  857.     INT_PTR nResult = dlgFile.DoModal();
  858.     pstrPath->ReleaseBuffer();
  859.     if (nResult != IDOK)
  860.         return FALSE;
  861.     return TRUE;
  862. }
  863.  
  864.  
  865. void CDxtexDoc::OpenSubsurface(D3DCUBEMAP_FACES FaceType, LONG lwMip, LONG lwSlice)
  866. {
  867.     HRESULT hr;
  868.     CString fileName;
  869.     LPDIRECT3DDEVICE8 pd3ddev = PDxtexApp()->Pd3ddev();
  870.     LPDIRECT3DTEXTURE8 ptex = NULL;
  871.     LPDIRECT3DSURFACE8 psurfOrig = NULL;
  872.     LPDIRECT3DSURFACE8 psurfNew = NULL;
  873.  
  874.     if (!PromptForBmp(&fileName))
  875.         return;
  876.  
  877.     if (IsVolumeMap())
  878.     {
  879.         hr = D3DXCreateTextureFromFile(pd3ddev, fileName, &ptex);
  880.         hr = ptex->GetSurfaceLevel(0, &psurfOrig);
  881.     }
  882.     else if (IsCubeMap())
  883.     {
  884.         hr = ((LPDIRECT3DCUBETEXTURE8)m_ptexOrig)->GetCubeMapSurface(FaceType, lwMip, &psurfOrig);
  885.         if (m_ptexNew != NULL)
  886.             hr = ((LPDIRECT3DCUBETEXTURE8)m_ptexNew)->GetCubeMapSurface(FaceType, lwMip, &psurfNew);
  887.         hr = D3DXLoadSurfaceFromFile(psurfOrig, NULL, NULL, fileName, NULL, D3DX_FILTER_TRIANGLE, 0, NULL);
  888.     }
  889.     else
  890.     {
  891.         hr = ((LPDIRECT3DTEXTURE8)m_ptexOrig)->GetSurfaceLevel(lwMip, &psurfOrig);
  892.         if (m_ptexNew != NULL)
  893.             hr = ((LPDIRECT3DTEXTURE8)m_ptexNew)->GetSurfaceLevel(lwMip, &psurfNew);
  894.         hr = D3DXLoadSurfaceFromFile(psurfOrig, NULL, NULL, fileName, NULL, D3DX_FILTER_TRIANGLE, 0, NULL);
  895.     }
  896.  
  897.     // Look for "foo_a.bmp" for alpha channel
  898.     int i = fileName.ReverseFind('.');
  899.     fileName = fileName.Left(i) + "_a.bmp";
  900.     CFileStatus status;
  901.     if (CFile::GetStatus(fileName, status))
  902.     {
  903.         if (FAILED(hr = LoadAlphaIntoSurface(fileName, psurfOrig)))
  904.             return;
  905.     }
  906.  
  907.     if (IsVolumeMap())
  908.     {
  909.         LPDIRECT3DVOLUME8 pvol;
  910.         hr = ((LPDIRECT3DVOLUMETEXTURE8)m_ptexOrig)->GetVolumeLevel(lwMip, &pvol);
  911.         hr = LoadVolumeSliceFromSurface(pvol, lwSlice, psurfOrig);
  912.         ReleasePpo(&pvol);
  913.         if (m_ptexNew)
  914.         {
  915.             hr = ((LPDIRECT3DVOLUMETEXTURE8)m_ptexNew)->GetVolumeLevel(lwMip, &pvol);
  916.             hr = LoadVolumeSliceFromSurface(pvol, lwSlice, psurfOrig);
  917.             ReleasePpo(&pvol);
  918.         }
  919.     }
  920.     else if (psurfNew != NULL)
  921.     {
  922.         hr = D3DXLoadSurfaceFromSurface(psurfNew, NULL, NULL, psurfOrig, NULL, NULL, D3DX_FILTER_TRIANGLE, 0);
  923.     }
  924.  
  925.     ReleasePpo(&psurfOrig);
  926.     ReleasePpo(&psurfNew);
  927.     ReleasePpo(&ptex);
  928.  
  929.     SetModifiedFlag(TRUE);
  930.     UpdateAllViews(NULL, 1);
  931. }
  932.  
  933.  
  934. void CDxtexDoc::OpenAlphaSubsurface(D3DCUBEMAP_FACES FaceType, LONG lwMip, LONG lwSlice)
  935. {
  936.     HRESULT hr;
  937.     CString fileName;
  938.     LPDIRECT3DDEVICE8 pd3ddev = PDxtexApp()->Pd3ddev();
  939.     LPDIRECT3DTEXTURE8 ptexOrig = NULL;
  940.     LPDIRECT3DTEXTURE8 ptexNew = NULL;
  941.     LPDIRECT3DSURFACE8 psurfOrig = NULL;
  942.     LPDIRECT3DSURFACE8 psurfNew = NULL;
  943.     LPDIRECT3DVOLUME8 pvolOrig = NULL;
  944.     LPDIRECT3DVOLUME8 pvolNew = NULL;
  945.     D3DSURFACE_DESC sd;
  946.     DWORD dwWidth = m_dwWidth;
  947.     DWORD dwHeight = m_dwHeight;
  948.  
  949.     if (IsVolumeMap())
  950.     {
  951.         for (int i = 0; i < lwMip; i++)
  952.         {
  953.             dwWidth /= 2;
  954.             dwHeight /= 2;
  955.         }
  956.         hr = pd3ddev->CreateTexture(dwWidth, dwHeight, 1, 
  957.              0, D3DFMT_A8R8G8B8, D3DPOOL_MANAGED, &ptexOrig);
  958.         hr = ptexOrig->GetSurfaceLevel(0, &psurfOrig);
  959.         hr = ((LPDIRECT3DVOLUMETEXTURE8)m_ptexOrig)->GetVolumeLevel(lwMip, &pvolOrig);
  960.         hr = LoadSurfaceFromVolumeSlice(pvolOrig, lwSlice, psurfOrig);
  961.         if (m_ptexNew != NULL)
  962.         {
  963.             hr = pd3ddev->CreateTexture(dwWidth, dwHeight, 1, 
  964.                  0, D3DFMT_A8R8G8B8, D3DPOOL_MANAGED, &ptexNew);
  965.             hr = ptexNew->GetSurfaceLevel(0, &psurfOrig);
  966.             hr = ((LPDIRECT3DVOLUMETEXTURE8)m_ptexOrig)->GetVolumeLevel(lwMip, &pvolNew);
  967.             hr = LoadSurfaceFromVolumeSlice(pvolNew, lwSlice, psurfOrig);
  968.         }
  969.     }
  970.     else if (IsCubeMap())
  971.     {
  972.         hr = ((LPDIRECT3DCUBETEXTURE8)m_ptexOrig)->GetCubeMapSurface(FaceType, lwMip, &psurfOrig);
  973.         ((LPDIRECT3DCUBETEXTURE8)m_ptexOrig)->GetLevelDesc(lwMip, &sd);
  974.         if (sd.Format == D3DFMT_DXT2 || sd.Format == D3DFMT_DXT4)
  975.         {
  976.             AfxMessageBox(ID_ERROR_PREMULTALPHA);
  977.             return;
  978.         }
  979.         if (m_ptexNew != NULL)
  980.         {
  981.             hr = ((LPDIRECT3DCUBETEXTURE8)m_ptexNew)->GetCubeMapSurface(FaceType, lwMip, &psurfNew);
  982.             ((LPDIRECT3DCUBETEXTURE8)m_ptexNew)->GetLevelDesc(lwMip, &sd);
  983.             if (sd.Format == D3DFMT_DXT2 || sd.Format == D3DFMT_DXT4)
  984.             {
  985.                 AfxMessageBox(ID_ERROR_PREMULTALPHA);
  986.                 return;
  987.             }
  988.         }
  989.     }
  990.     else
  991.     {
  992.         BOOL bAlphaFound = FALSE;
  993.         hr = ((LPDIRECT3DTEXTURE8)m_ptexOrig)->GetSurfaceLevel(lwMip, &psurfOrig);
  994.         ((LPDIRECT3DTEXTURE8)m_ptexOrig)->GetLevelDesc(lwMip, &sd);
  995.         if (sd.Format == D3DFMT_DXT2 || sd.Format == D3DFMT_DXT4)
  996.         {
  997.             AfxMessageBox(ID_ERROR_PREMULTALPHA);
  998.             return;
  999.         }
  1000.  
  1001.         // Check if the original has alpha
  1002.         if( sd.Format == D3DFMT_A8R8G8B8 || 
  1003.             sd.Format == D3DFMT_A1R5G5B5 || 
  1004.             sd.Format == D3DFMT_A4R4G4B4 || 
  1005.             sd.Format == D3DFMT_A8R3G3B2 ||
  1006.             sd.Format == D3DFMT_DXT1 ||
  1007.             sd.Format == D3DFMT_DXT3 ||
  1008.             sd.Format == D3DFMT_DXT5 )
  1009.         {
  1010.             bAlphaFound = TRUE;
  1011.         }
  1012.  
  1013.         if (m_ptexNew != NULL)
  1014.         {
  1015.             hr = ((LPDIRECT3DTEXTURE8)m_ptexNew)->GetSurfaceLevel(lwMip, &psurfNew);
  1016.             ((LPDIRECT3DTEXTURE8)m_ptexNew)->GetLevelDesc(lwMip, &sd);
  1017.             if (sd.Format == D3DFMT_DXT2 || sd.Format == D3DFMT_DXT4)
  1018.             {
  1019.                 AfxMessageBox(ID_ERROR_PREMULTALPHA);
  1020.                 return;
  1021.             }
  1022.             // Check if the new has alpha
  1023.             if( sd.Format == D3DFMT_A8R8G8B8 || 
  1024.                 sd.Format == D3DFMT_A1R5G5B5 || 
  1025.                 sd.Format == D3DFMT_A4R4G4B4 || 
  1026.                 sd.Format == D3DFMT_A8R3G3B2 ||
  1027.                 sd.Format == D3DFMT_DXT1 ||
  1028.                 sd.Format == D3DFMT_DXT3 ||
  1029.                 sd.Format == D3DFMT_DXT5 )
  1030.             {
  1031.                 bAlphaFound = TRUE;
  1032.             }
  1033.         }
  1034.  
  1035.         if( bAlphaFound == FALSE )
  1036.         {
  1037.             AfxMessageBox(ID_ERROR_NEEDALPHA);
  1038.             return;
  1039.         }
  1040.     }
  1041.  
  1042.     if (!PromptForBmp(&fileName))
  1043.         return;
  1044.  
  1045.     if (FAILED(hr = LoadAlphaIntoSurface(fileName, psurfOrig)))
  1046.         return;
  1047.  
  1048.     if (psurfNew != NULL)
  1049.     {
  1050.         if (FAILED(hr = LoadAlphaIntoSurface(fileName, psurfNew)))
  1051.             return;
  1052.     }
  1053.  
  1054.     if (pvolOrig != NULL)
  1055.     {
  1056.         hr = LoadVolumeSliceFromSurface(pvolOrig, lwSlice, psurfOrig);
  1057.     }
  1058.     if (pvolNew != NULL)
  1059.     {
  1060.         hr = LoadVolumeSliceFromSurface(pvolNew, lwSlice, psurfNew);
  1061.     }
  1062.  
  1063.     ReleasePpo(&psurfOrig);
  1064.     ReleasePpo(&psurfNew);
  1065.     ReleasePpo(&ptexOrig);
  1066.     ReleasePpo(&ptexNew);
  1067.     ReleasePpo(&pvolOrig);
  1068.     ReleasePpo(&pvolNew);
  1069.  
  1070.     SetModifiedFlag(TRUE);
  1071.     UpdateAllViews(NULL, 1);
  1072. }
  1073.  
  1074.  
  1075. void CDxtexDoc::OnFormatChangeCubeMapFaces() 
  1076. {
  1077.     HRESULT hr;
  1078.     LPDIRECT3DDEVICE8 pd3ddev = PDxtexApp()->Pd3ddev();
  1079.     D3DSURFACE_DESC sd;
  1080.     LPDIRECT3DCUBETEXTURE8 ptexCube;
  1081.     DWORD iLevel;
  1082.     LPDIRECT3DSURFACE8 psurfSrc;
  1083.     LPDIRECT3DSURFACE8 psurfDest;
  1084.  
  1085.     CCubeMapDlg cubeMapDlg;
  1086.     if (IDCANCEL == cubeMapDlg.DoModal())
  1087.         return;
  1088.     
  1089.     // Change m_ptexOrig into a cubemap
  1090.     ((LPDIRECT3DTEXTURE8)m_ptexOrig)->GetLevelDesc(0, &sd);
  1091.     hr = D3DXCreateCubeTexture(pd3ddev, m_dwWidth, m_numMips, 0, sd.Format, D3DPOOL_MANAGED, &ptexCube);
  1092.     for (iLevel = 0; iLevel < m_numMips; iLevel++)
  1093.     {
  1094.         hr = ((LPDIRECT3DTEXTURE8)m_ptexOrig)->GetSurfaceLevel(iLevel, &psurfSrc);
  1095.         hr = ptexCube->GetCubeMapSurface((D3DCUBEMAP_FACES)cubeMapDlg.m_iFace, iLevel, &psurfDest);
  1096.         hr = D3DXLoadSurfaceFromSurface(psurfDest, NULL, NULL, 
  1097.             psurfSrc, NULL, NULL, D3DX_FILTER_TRIANGLE, 0);
  1098.         ReleasePpo(&psurfSrc);
  1099.         ReleasePpo(&psurfDest);
  1100.     }
  1101.     ReleasePpo(&m_ptexOrig);
  1102.     m_ptexOrig = ptexCube;
  1103.  
  1104.     // Change m_ptexNew into a cubemap too
  1105.     if (m_ptexNew != NULL)
  1106.     {
  1107.         ((LPDIRECT3DTEXTURE8)m_ptexNew)->GetLevelDesc(0, &sd);
  1108.         hr = D3DXCreateCubeTexture(pd3ddev, m_dwWidth, m_numMips, 0, sd.Format, D3DPOOL_MANAGED, &ptexCube);
  1109.         for (iLevel = 0; iLevel < m_numMips; iLevel++)
  1110.         {
  1111.             hr = ((LPDIRECT3DTEXTURE8)m_ptexNew)->GetSurfaceLevel(iLevel, &psurfSrc);
  1112.             hr = ptexCube->GetCubeMapSurface((D3DCUBEMAP_FACES)cubeMapDlg.m_iFace, iLevel, &psurfDest);
  1113.             hr = D3DXLoadSurfaceFromSurface(psurfDest, NULL, NULL, 
  1114.                 psurfSrc, NULL, NULL, D3DX_FILTER_TRIANGLE, 0);
  1115.             ReleasePpo(&psurfSrc);
  1116.             ReleasePpo(&psurfDest);
  1117.         }
  1118.         ReleasePpo(&m_ptexNew);
  1119.         m_ptexNew = ptexCube;
  1120.     }
  1121.     m_dwCubeMapFlags = DDS_CUBEMAP_ALLFACES;
  1122.     SetModifiedFlag();
  1123.     UpdateAllViews(NULL, 1); // tell CView to pick up new surface pointers
  1124. }
  1125.  
  1126.  
  1127. void CDxtexDoc::OnFormatMakeIntoVolumeMap() 
  1128. {
  1129.     HRESULT hr;
  1130.     LPDIRECT3DDEVICE8 pd3ddev = PDxtexApp()->Pd3ddev();
  1131.     D3DSURFACE_DESC sd;
  1132.     LPDIRECT3DVOLUMETEXTURE8 ptexVolume;
  1133.     DWORD iLevel;
  1134.     LPDIRECT3DSURFACE8 psurfSrc;
  1135.     LPDIRECT3DVOLUME8 pvolumeDest;
  1136.     UINT numLayers;
  1137.  
  1138.     CVolumeMapDlg volumeMapDlg;
  1139.     if (IDCANCEL == volumeMapDlg.DoModal())
  1140.         return;
  1141.  
  1142.     numLayers = (1 << volumeMapDlg.m_powLayers) * 2;
  1143.  
  1144.     // Change m_ptexOrig into a volumemap
  1145.     ((LPDIRECT3DTEXTURE8)m_ptexOrig)->GetLevelDesc(0, &sd);
  1146.     hr = pd3ddev->CreateVolumeTexture(m_dwWidth, m_dwHeight, numLayers,
  1147.         m_numMips, 0, sd.Format, D3DPOOL_SYSTEMMEM, &ptexVolume);
  1148.     if (FAILED(hr))
  1149.         return;
  1150.     for (iLevel = 0; iLevel < m_numMips; iLevel++)
  1151.     {
  1152.         hr = ((LPDIRECT3DTEXTURE8)m_ptexOrig)->GetSurfaceLevel(iLevel, &psurfSrc);
  1153.         hr = ptexVolume->GetVolumeLevel(iLevel, &pvolumeDest);
  1154.         hr = LoadVolumeSliceFromSurface(pvolumeDest, 0, psurfSrc);
  1155.         ReleasePpo(&psurfSrc);
  1156.         ReleasePpo(&pvolumeDest);
  1157.     }
  1158.     ReleasePpo(&m_ptexOrig);
  1159.     m_ptexOrig = ptexVolume;
  1160.  
  1161.     // Change m_ptexNew into a volumemap too
  1162.     if (m_ptexNew != NULL)
  1163.     {
  1164.         ((LPDIRECT3DTEXTURE8)m_ptexNew)->GetLevelDesc(0, &sd);
  1165.         hr = pd3ddev->CreateVolumeTexture(m_dwWidth, m_dwHeight, numLayers,
  1166.             m_numMips, 0, sd.Format, D3DPOOL_SYSTEMMEM, &ptexVolume);
  1167.         if (FAILED(hr))
  1168.             return;
  1169.         for (iLevel = 0; iLevel < m_numMips; iLevel++)
  1170.         {
  1171.             hr = ((LPDIRECT3DTEXTURE8)m_ptexNew)->GetSurfaceLevel(iLevel, &psurfSrc);
  1172.             hr = ptexVolume->GetVolumeLevel(iLevel, &pvolumeDest);
  1173.             hr = LoadVolumeSliceFromSurface(pvolumeDest, 0, psurfSrc);
  1174.             ReleasePpo(&psurfSrc);
  1175.             ReleasePpo(&pvolumeDest);
  1176.         }
  1177.         ReleasePpo(&m_ptexNew);
  1178.         m_ptexNew = ptexVolume;
  1179.     }
  1180.     m_dwDepth = numLayers;
  1181.     SetModifiedFlag();
  1182.     UpdateAllViews(NULL, 1); // tell CView to pick up new surface pointers
  1183. }
  1184.  
  1185.  
  1186. HRESULT CDxtexDoc::LoadVolumeSliceFromSurface(LPDIRECT3DVOLUME8 pVolume, UINT iSlice, LPDIRECT3DSURFACE8 psurf)
  1187. {
  1188.     HRESULT hr;
  1189.     D3DSURFACE_DESC sd;
  1190.     D3DVOLUME_DESC vd;
  1191.     D3DLOCKED_RECT lr;
  1192.     D3DBOX boxSrc;
  1193.     D3DBOX boxDest;
  1194.  
  1195.     psurf->GetDesc(&sd);
  1196.     pVolume->GetDesc(&vd);
  1197.  
  1198.     boxSrc.Left = 0;
  1199.     boxSrc.Right = sd.Width;
  1200.     boxSrc.Top = 0;
  1201.     boxSrc.Bottom = sd.Height;
  1202.     boxSrc.Front = 0;
  1203.     boxSrc.Back = 1;
  1204.  
  1205.     boxDest.Left = 0;
  1206.     boxDest.Right = vd.Width;
  1207.     boxDest.Top = 0;
  1208.     boxDest.Bottom = vd.Height;
  1209.     boxDest.Front = iSlice;
  1210.     boxDest.Back = iSlice + 1;
  1211.  
  1212.     hr = psurf->LockRect(&lr, NULL, 0);
  1213.     if (FAILED(hr))
  1214.         return hr;
  1215.  
  1216.     hr = D3DXLoadVolumeFromMemory(pVolume, NULL, &boxDest, lr.pBits, sd.Format, lr.Pitch, 
  1217.         0, NULL, &boxSrc, D3DX_FILTER_TRIANGLE, 0);
  1218.  
  1219.     psurf->UnlockRect();
  1220.  
  1221.     return hr;
  1222. }
  1223.  
  1224.  
  1225. HRESULT CDxtexDoc::LoadSurfaceFromVolumeSlice(LPDIRECT3DVOLUME8 pVolume, UINT iSlice, LPDIRECT3DSURFACE8 psurf)
  1226. {
  1227.     HRESULT hr;
  1228.     D3DVOLUME_DESC vd;
  1229.     D3DLOCKED_BOX lb;
  1230.     D3DBOX box;
  1231.     RECT rc;
  1232.  
  1233.     pVolume->GetDesc(&vd);
  1234.  
  1235.     box.Left = 0;
  1236.     box.Right = vd.Width;
  1237.     box.Top = 0;
  1238.     box.Bottom = vd.Height;
  1239.     box.Front = iSlice;
  1240.     box.Back = iSlice + 1;
  1241.  
  1242.     rc.left = 0;
  1243.     rc.right = vd.Width;
  1244.     rc.top = 0;
  1245.     rc.bottom = vd.Height;
  1246.  
  1247.     hr = pVolume->LockBox(&lb, &box, 0);
  1248.     if (FAILED(hr))
  1249.         return hr;
  1250.  
  1251.     hr = D3DXLoadSurfaceFromMemory(psurf, NULL, NULL, lb.pBits, vd.Format, lb.RowPitch, 
  1252.         NULL, &rc, D3DX_FILTER_TRIANGLE, 0);
  1253.  
  1254.     pVolume->UnlockBox();
  1255.  
  1256.     return hr;
  1257. }
  1258.  
  1259.  
  1260. HRESULT CDxtexDoc::BltAllLevels(D3DCUBEMAP_FACES FaceType, 
  1261.     LPDIRECT3DBASETEXTURE8 ptexSrc, LPDIRECT3DBASETEXTURE8 ptexDest)
  1262. {
  1263.     HRESULT hr;
  1264.     LPDIRECT3DTEXTURE8 pmiptexSrc;
  1265.     LPDIRECT3DTEXTURE8 pmiptexDest;
  1266.     LPDIRECT3DCUBETEXTURE8 pcubetexSrc;
  1267.     LPDIRECT3DCUBETEXTURE8 pcubetexDest;
  1268.     LPDIRECT3DVOLUMETEXTURE8 pvoltexSrc;
  1269.     LPDIRECT3DVOLUMETEXTURE8 pvoltexDest;
  1270.     DWORD iLevel;
  1271.  
  1272.     if (IsVolumeMap())
  1273.     {
  1274.         pvoltexSrc = (LPDIRECT3DVOLUMETEXTURE8)ptexSrc;
  1275.         pvoltexDest = (LPDIRECT3DVOLUMETEXTURE8)ptexDest;
  1276.     }
  1277.     else if (IsCubeMap())
  1278.     {
  1279.         pcubetexSrc = (LPDIRECT3DCUBETEXTURE8)ptexSrc;
  1280.         pcubetexDest = (LPDIRECT3DCUBETEXTURE8)ptexDest;
  1281.     }
  1282.     else
  1283.     {
  1284.         pmiptexSrc = (LPDIRECT3DTEXTURE8)ptexSrc;
  1285.         pmiptexDest = (LPDIRECT3DTEXTURE8)ptexDest;
  1286.     }
  1287.  
  1288.     for (iLevel = 0; iLevel < m_numMips; iLevel++)
  1289.     {
  1290.         if (IsVolumeMap())
  1291.         {
  1292.             LPDIRECT3DVOLUME8 pvolSrc = NULL;
  1293.             LPDIRECT3DVOLUME8 pvolDest = NULL;
  1294.             hr = pvoltexSrc->GetVolumeLevel(iLevel, &pvolSrc);
  1295.             hr = pvoltexDest->GetVolumeLevel(iLevel, &pvolDest);
  1296.             hr = D3DXLoadVolumeFromVolume(pvolDest, NULL, NULL, 
  1297.                 pvolSrc, NULL, NULL, D3DX_FILTER_TRIANGLE, 0);
  1298.             ReleasePpo(&pvolSrc);
  1299.             ReleasePpo(&pvolDest);
  1300.         }
  1301.         else if (IsCubeMap())
  1302.         {
  1303.             LPDIRECT3DSURFACE8 psurfSrc = NULL;
  1304.             LPDIRECT3DSURFACE8 psurfDest = NULL;
  1305.             hr = pcubetexSrc->GetCubeMapSurface(FaceType, iLevel, &psurfSrc);
  1306.             hr = pcubetexDest->GetCubeMapSurface(FaceType, iLevel, &psurfDest);
  1307.             hr = D3DXLoadSurfaceFromSurface(psurfDest, NULL, NULL, 
  1308.                 psurfSrc, NULL, NULL, D3DX_FILTER_TRIANGLE, 0);
  1309.             ReleasePpo(&psurfSrc);
  1310.             ReleasePpo(&psurfDest);
  1311.         }
  1312.         else
  1313.         {
  1314.             LPDIRECT3DSURFACE8 psurfSrc = NULL;
  1315.             LPDIRECT3DSURFACE8 psurfDest = NULL;
  1316.             hr = pmiptexSrc->GetSurfaceLevel(iLevel, &psurfSrc);
  1317.             hr = pmiptexDest->GetSurfaceLevel(iLevel, &psurfDest);
  1318.             hr = D3DXLoadSurfaceFromSurface(psurfDest, NULL, NULL, 
  1319.                 psurfSrc, NULL, NULL, D3DX_FILTER_TRIANGLE, 0);
  1320.             ReleasePpo(&psurfSrc);
  1321.             ReleasePpo(&psurfDest);
  1322.         }
  1323.     }
  1324.  
  1325.     return S_OK;
  1326. }
  1327.  
  1328.  
  1329. void CDxtexDoc::OpenCubeFace(D3DCUBEMAP_FACES FaceType)
  1330. {
  1331.     HRESULT hr;
  1332.     CString fileName;
  1333.     LPDIRECT3DSURFACE8 psurfOrig = NULL;
  1334.     LPDIRECT3DSURFACE8 psurfNew = NULL;
  1335.  
  1336.     if (!IsCubeMap())
  1337.         return;
  1338.  
  1339.     hr = ((LPDIRECT3DCUBETEXTURE8)m_ptexOrig)->GetCubeMapSurface(FaceType, 0, &psurfOrig);
  1340.     if (m_ptexNew != NULL)
  1341.         hr = ((LPDIRECT3DCUBETEXTURE8)m_ptexNew)->GetCubeMapSurface(FaceType, 0, &psurfNew);
  1342.  
  1343.     if (!PromptForBmp(&fileName))
  1344.         return;
  1345.  
  1346.     hr = D3DXLoadSurfaceFromFile(psurfOrig, NULL, NULL, fileName, NULL, D3DX_FILTER_TRIANGLE, 0, NULL);
  1347.  
  1348.     // Look for "foo_a.bmp" for alpha channel
  1349.     int i = fileName.ReverseFind('.');
  1350.     fileName = fileName.Left(i) + "_a.bmp";
  1351.     CFileStatus status;
  1352.     if (CFile::GetStatus(fileName, status))
  1353.     {
  1354.         if (FAILED(hr = LoadAlphaIntoSurface(fileName, psurfOrig)))
  1355.             return;
  1356.     }
  1357.  
  1358.     if (m_numMips > 1)
  1359.     {
  1360.         hr = D3DXFilterCubeTexture((LPDIRECT3DCUBETEXTURE8)m_ptexOrig, NULL, 0, D3DX_FILTER_TRIANGLE);
  1361.     }
  1362.  
  1363.  
  1364.     if (psurfNew != NULL)
  1365.     {
  1366.         hr = D3DXLoadSurfaceFromSurface(psurfNew, NULL, NULL, psurfOrig, NULL, NULL, D3DX_FILTER_TRIANGLE, 0);
  1367.  
  1368.         if (m_numMips > 1)
  1369.         {
  1370.             hr = D3DXFilterCubeTexture((LPDIRECT3DCUBETEXTURE8)m_ptexNew, NULL, 0, D3DX_FILTER_TRIANGLE);
  1371.         }
  1372.     }
  1373.  
  1374.     ReleasePpo(&psurfOrig);
  1375.     ReleasePpo(&psurfNew);
  1376.  
  1377.     SetModifiedFlag(TRUE);
  1378.     UpdateAllViews(NULL, 1);
  1379. }
  1380.  
  1381.  
  1382. void CDxtexDoc::OpenAlphaCubeFace(D3DCUBEMAP_FACES FaceType)
  1383. {
  1384.     HRESULT hr;
  1385.     CString fileName;
  1386.     LPDIRECT3DSURFACE8 psurfOrig = NULL;
  1387.     LPDIRECT3DSURFACE8 psurfNew = NULL;
  1388.     D3DSURFACE_DESC sd;
  1389.  
  1390.     if (!IsCubeMap())
  1391.         return;
  1392.  
  1393.     hr = ((LPDIRECT3DCUBETEXTURE8)m_ptexOrig)->GetCubeMapSurface(FaceType, 0, &psurfOrig);
  1394.     ((LPDIRECT3DCUBETEXTURE8)m_ptexOrig)->GetLevelDesc(0, &sd);
  1395.     if (sd.Format == D3DFMT_DXT2 || sd.Format == D3DFMT_DXT4)
  1396.     {
  1397.         AfxMessageBox(ID_ERROR_PREMULTALPHA);
  1398.         return;
  1399.     }
  1400.     if (m_ptexNew != NULL)
  1401.     {
  1402.         hr = ((LPDIRECT3DCUBETEXTURE8)m_ptexNew)->GetCubeMapSurface(FaceType, 0, &psurfNew);
  1403.     }
  1404.  
  1405.     if (!PromptForBmp(&fileName))
  1406.         return;
  1407.  
  1408.     if (FAILED(hr = LoadAlphaIntoSurface(fileName, psurfOrig)))
  1409.         return;
  1410.  
  1411.     if (psurfNew != NULL)
  1412.     {
  1413.         if (FAILED(hr = LoadAlphaIntoSurface(fileName, psurfNew)))
  1414.             return;
  1415.     }
  1416.  
  1417.     if (m_numMips > 1)
  1418.     {
  1419.         hr = D3DXFilterCubeTexture((LPDIRECT3DCUBETEXTURE8)m_ptexOrig, NULL, 0, D3DX_FILTER_TRIANGLE);
  1420.     }
  1421.  
  1422.  
  1423.     if (psurfNew != NULL)
  1424.     {
  1425.         hr = D3DXLoadSurfaceFromSurface(psurfNew, NULL, NULL, psurfOrig, NULL, NULL, D3DX_FILTER_TRIANGLE, 0);
  1426.  
  1427.         if (m_numMips > 1)
  1428.         {
  1429.             hr = D3DXFilterCubeTexture((LPDIRECT3DCUBETEXTURE8)m_ptexNew, NULL, 0, D3DX_FILTER_TRIANGLE);
  1430.         }
  1431.     }
  1432.  
  1433.     ReleasePpo(&psurfOrig);
  1434.     ReleasePpo(&psurfNew);
  1435.  
  1436.     SetModifiedFlag(TRUE);
  1437.     UpdateAllViews(NULL, 1);
  1438. }
  1439.  
  1440.  
  1441. DWORD CDxtexDoc::DwDepthAt(LONG lwMip)
  1442. {
  1443.     DWORD dwDepth = m_dwDepth;
  1444.     while (lwMip > 0 && dwDepth > 1)
  1445.     {
  1446.         dwDepth /= 2;
  1447.         lwMip--;
  1448.     }
  1449.     return dwDepth;
  1450. }
  1451.  
  1452.  
  1453. void CDxtexDoc::OnFormatChangeSurfaceFmt() 
  1454. {
  1455.     CChangeFmtDlg changeFmtDlg;
  1456.     LPDIRECT3DBASETEXTURE8 ptex;
  1457.  
  1458.     ptex = (m_ptexNew == NULL ? m_ptexOrig : m_ptexNew);
  1459.  
  1460.     if (IsVolumeMap())
  1461.     {
  1462.         D3DVOLUME_DESC vd;
  1463.         ((LPDIRECT3DVOLUMETEXTURE8)ptex)->GetLevelDesc(0, &vd);
  1464.         changeFmtDlg.m_fmt = vd.Format;
  1465.     }
  1466.     else if (IsCubeMap())
  1467.     {
  1468.         D3DSURFACE_DESC sd;
  1469.         ((LPDIRECT3DCUBETEXTURE8)ptex)->GetLevelDesc(0, &sd);
  1470.         changeFmtDlg.m_fmt = sd.Format;
  1471.     }
  1472.     else
  1473.     {
  1474.         D3DSURFACE_DESC sd;
  1475.         ((LPDIRECT3DTEXTURE8)ptex)->GetLevelDesc(0, &sd);
  1476.         changeFmtDlg.m_fmt = sd.Format;
  1477.     }
  1478.  
  1479.     changeFmtDlg.m_bVolume = IsVolumeMap();
  1480.  
  1481.     if (IDCANCEL == changeFmtDlg.DoModal())
  1482.         return;
  1483.  
  1484.     Compress(changeFmtDlg.m_fmt, TRUE);
  1485. }
  1486.  
  1487.  
  1488. void CDxtexDoc::OnUpdateFileOpenAlpha(CCmdUI* pCmdUI) 
  1489. {
  1490.     pCmdUI->Enable(!IsCubeMap() && !IsVolumeMap()); 
  1491. }
  1492.  
  1493.  
  1494. void CDxtexDoc::OnUpdateFormatGenerateMipmaps(CCmdUI* pCmdUI) 
  1495. {
  1496.     pCmdUI->Enable(m_numMips <= 1); 
  1497. }
  1498.  
  1499.  
  1500. void CDxtexDoc::OnUpdateFormatChangeCubeMapFaces(CCmdUI* pCmdUI) 
  1501. {
  1502.     pCmdUI->Enable(!IsCubeMap() && !IsVolumeMap()); 
  1503. }
  1504.  
  1505.  
  1506. void CDxtexDoc::OnUpdateFormatMakeIntoVolumeMap(CCmdUI* pCmdUI) 
  1507. {
  1508.     pCmdUI->Enable(!IsCubeMap() && !IsVolumeMap());
  1509. }
  1510.  
  1511.  
  1512.